home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / UserDict.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  7.7 KB  |  295 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4.  
  5. class UserDict:
  6.     
  7.     def __init__(self, dict = None, **kwargs):
  8.         self.data = { }
  9.         if dict is not None:
  10.             self.update(dict)
  11.         
  12.         if len(kwargs):
  13.             self.update(kwargs)
  14.         
  15.  
  16.     
  17.     def __repr__(self):
  18.         return repr(self.data)
  19.  
  20.     
  21.     def __cmp__(self, dict):
  22.         if isinstance(dict, UserDict):
  23.             return cmp(self.data, dict.data)
  24.         else:
  25.             return cmp(self.data, dict)
  26.  
  27.     
  28.     def __len__(self):
  29.         return len(self.data)
  30.  
  31.     
  32.     def __getitem__(self, key):
  33.         if key in self.data:
  34.             return self.data[key]
  35.         
  36.         if hasattr(self.__class__, '__missing__'):
  37.             return self.__class__.__missing__(self, key)
  38.         
  39.         raise KeyError(key)
  40.  
  41.     
  42.     def __setitem__(self, key, item):
  43.         self.data[key] = item
  44.  
  45.     
  46.     def __delitem__(self, key):
  47.         del self.data[key]
  48.  
  49.     
  50.     def clear(self):
  51.         self.data.clear()
  52.  
  53.     
  54.     def copy(self):
  55.         if self.__class__ is UserDict:
  56.             return UserDict(self.data.copy())
  57.         
  58.         import copy
  59.         data = self.data
  60.         
  61.         try:
  62.             self.data = { }
  63.             c = copy.copy(self)
  64.         finally:
  65.             self.data = data
  66.  
  67.         c.update(self)
  68.         return c
  69.  
  70.     
  71.     def keys(self):
  72.         return self.data.keys()
  73.  
  74.     
  75.     def items(self):
  76.         return self.data.items()
  77.  
  78.     
  79.     def iteritems(self):
  80.         return self.data.iteritems()
  81.  
  82.     
  83.     def iterkeys(self):
  84.         return self.data.iterkeys()
  85.  
  86.     
  87.     def itervalues(self):
  88.         return self.data.itervalues()
  89.  
  90.     
  91.     def values(self):
  92.         return self.data.values()
  93.  
  94.     
  95.     def has_key(self, key):
  96.         return self.data.has_key(key)
  97.  
  98.     
  99.     def update(self, dict = None, **kwargs):
  100.         if dict is None:
  101.             pass
  102.         elif isinstance(dict, UserDict):
  103.             self.data.update(dict.data)
  104.         elif isinstance(dict, type({ })) or not hasattr(dict, 'items'):
  105.             self.data.update(dict)
  106.         else:
  107.             for k, v in dict.items():
  108.                 self[k] = v
  109.             
  110.         if len(kwargs):
  111.             self.data.update(kwargs)
  112.         
  113.  
  114.     
  115.     def get(self, key, failobj = None):
  116.         if not self.has_key(key):
  117.             return failobj
  118.         
  119.         return self[key]
  120.  
  121.     
  122.     def setdefault(self, key, failobj = None):
  123.         if not self.has_key(key):
  124.             self[key] = failobj
  125.         
  126.         return self[key]
  127.  
  128.     
  129.     def pop(self, key, *args):
  130.         return self.data.pop(key, *args)
  131.  
  132.     
  133.     def popitem(self):
  134.         return self.data.popitem()
  135.  
  136.     
  137.     def __contains__(self, key):
  138.         return key in self.data
  139.  
  140.     
  141.     def fromkeys(cls, iterable, value = None):
  142.         d = cls()
  143.         for key in iterable:
  144.             d[key] = value
  145.         
  146.         return d
  147.  
  148.     fromkeys = classmethod(fromkeys)
  149.  
  150.  
  151. class IterableUserDict(UserDict):
  152.     
  153.     def __iter__(self):
  154.         return iter(self.data)
  155.  
  156.  
  157.  
  158. class DictMixin:
  159.     
  160.     def __iter__(self):
  161.         for k in self.keys():
  162.             yield k
  163.         
  164.  
  165.     
  166.     def has_key(self, key):
  167.         
  168.         try:
  169.             value = self[key]
  170.         except KeyError:
  171.             return False
  172.  
  173.         return True
  174.  
  175.     
  176.     def __contains__(self, key):
  177.         return self.has_key(key)
  178.  
  179.     
  180.     def iteritems(self):
  181.         for k in self:
  182.             yield (k, self[k])
  183.         
  184.  
  185.     
  186.     def iterkeys(self):
  187.         return self.__iter__()
  188.  
  189.     
  190.     def itervalues(self):
  191.         for _, v in self.iteritems():
  192.             yield v
  193.         
  194.  
  195.     
  196.     def values(self):
  197.         return [ v for _, v in self.iteritems() ]
  198.  
  199.     
  200.     def items(self):
  201.         return list(self.iteritems())
  202.  
  203.     
  204.     def clear(self):
  205.         for key in self.keys():
  206.             del self[key]
  207.         
  208.  
  209.     
  210.     def setdefault(self, key, default = None):
  211.         
  212.         try:
  213.             return self[key]
  214.         except KeyError:
  215.             self[key] = default
  216.  
  217.         return default
  218.  
  219.     
  220.     def pop(self, key, *args):
  221.         if len(args) > 1:
  222.             raise TypeError, 'pop expected at most 2 arguments, got ' + repr(1 + len(args))
  223.         
  224.         
  225.         try:
  226.             value = self[key]
  227.         except KeyError:
  228.             if args:
  229.                 return args[0]
  230.             
  231.             raise 
  232.  
  233.         del self[key]
  234.         return value
  235.  
  236.     
  237.     def popitem(self):
  238.         
  239.         try:
  240.             (k, v) = self.iteritems().next()
  241.         except StopIteration:
  242.             raise KeyError, 'container is empty'
  243.  
  244.         del self[k]
  245.         return (k, v)
  246.  
  247.     
  248.     def update(self, other = None, **kwargs):
  249.         if other is None:
  250.             pass
  251.         elif hasattr(other, 'iteritems'):
  252.             for k, v in other.iteritems():
  253.                 self[k] = v
  254.             
  255.         elif hasattr(other, 'keys'):
  256.             for k in other.keys():
  257.                 self[k] = other[k]
  258.             
  259.         else:
  260.             for k, v in other:
  261.                 self[k] = v
  262.             
  263.         if kwargs:
  264.             self.update(kwargs)
  265.         
  266.  
  267.     
  268.     def get(self, key, default = None):
  269.         
  270.         try:
  271.             return self[key]
  272.         except KeyError:
  273.             return default
  274.  
  275.  
  276.     
  277.     def __repr__(self):
  278.         return repr(dict(self.iteritems()))
  279.  
  280.     
  281.     def __cmp__(self, other):
  282.         if other is None:
  283.             return 1
  284.         
  285.         if isinstance(other, DictMixin):
  286.             other = dict(other.iteritems())
  287.         
  288.         return cmp(dict(self.iteritems()), other)
  289.  
  290.     
  291.     def __len__(self):
  292.         return len(self.keys())
  293.  
  294.  
  295.